home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 22 / CU Amiga Magazine's Super CD-ROM 22 (1998)(EMAP Images)(GB)[!][issue 1998-05].iso / PowerPC / Programming / PPCSmallEiffel / bin_c / pretty32.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  7.8 KB  |  518 lines

  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.82)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "pretty.h"
  9. T7*e2s(char*e){
  10. return se_ms(strlen(e),e);}
  11. char*s2e(T7*s){
  12. char*e=malloc(1+s->_count);
  13. memcpy(e,s->_storage,s->_count);
  14. e[s->_count]='\0';
  15. return e;}
  16. void*se_ma65(int argc,...){
  17. T65*m;
  18. va_list pa;
  19. T0**s;
  20. m=malloc(sizeof(*m));
  21. *m=M65;
  22. if(argc){
  23. s=malloc(argc*sizeof(*s));
  24. m->_storage=s;
  25. m->_capacity=argc;
  26. m->_lower=1;
  27. m->_upper=argc;
  28. va_start(pa,argc);
  29. while(argc--){
  30. *(s++)=((void*)(va_arg(pa,char*)));
  31. }
  32. va_end(pa);
  33. }
  34. return m;}
  35. void*se_ma901(int argc,...){
  36. T901*m;
  37. va_list pa;
  38. T0**s;
  39. m=malloc(sizeof(*m));
  40. *m=M901;
  41. if(argc){
  42. s=malloc(argc*sizeof(*s));
  43. m->_storage=s;
  44. m->_capacity=argc;
  45. m->_lower=1;
  46. m->_upper=argc;
  47. va_start(pa,argc);
  48. while(argc--){
  49. *(s++)=((void*)(va_arg(pa,char*)));
  50. }
  51. va_end(pa);
  52. }
  53. return m;}
  54. void*se_ma263(int argc,...){
  55. T263*m;
  56. va_list pa;
  57. T0**s;
  58. m=malloc(sizeof(*m));
  59. *m=M263;
  60. if(argc){
  61. s=malloc(argc*sizeof(*s));
  62. m->_storage=s;
  63. m->_capacity=argc;
  64. m->_lower=1;
  65. m->_upper=argc;
  66. va_start(pa,argc);
  67. while(argc--){
  68. *(s++)=((void*)(va_arg(pa,char*)));
  69. }
  70. va_end(pa);
  71. }
  72. return m;}
  73. void*se_ma522(int argc,...){
  74. T522*m;
  75. va_list pa;
  76. T0**s;
  77. m=malloc(sizeof(*m));
  78. *m=M522;
  79. if(argc){
  80. s=malloc(argc*sizeof(*s));
  81. m->_storage=s;
  82. m->_capacity=argc;
  83. m->_lower=1;
  84. m->_upper=argc;
  85. va_start(pa,argc);
  86. while(argc--){
  87. *(s++)=((void*)(va_arg(pa,char*)));
  88. }
  89. va_end(pa);
  90. }
  91. return m;}
  92. void*se_ma587(int argc,...){
  93. T587*m;
  94. va_list pa;
  95. T0**s;
  96. m=malloc(sizeof(*m));
  97. *m=M587;
  98. if(argc){
  99. s=malloc(argc*sizeof(*s));
  100. m->_storage=s;
  101. m->_capacity=argc;
  102. m->_lower=1;
  103. m->_upper=argc;
  104. va_start(pa,argc);
  105. while(argc--){
  106. *(s++)=((void*)(va_arg(pa,char*)));
  107. }
  108. va_end(pa);
  109. }
  110. return m;}
  111. void*se_ma396(int argc,...){
  112. T396*m;
  113. va_list pa;
  114. T0**s;
  115. m=malloc(sizeof(*m));
  116. *m=M396;
  117. if(argc){
  118. s=malloc(argc*sizeof(*s));
  119. m->_storage=s;
  120. m->_capacity=argc;
  121. m->_lower=1;
  122. m->_upper=argc;
  123. va_start(pa,argc);
  124. while(argc--){
  125. *(s++)=((void*)(va_arg(pa,char*)));
  126. }
  127. va_end(pa);
  128. }
  129. return m;}
  130. void*se_ma848(int argc,...){
  131. T848*m;
  132. va_list pa;
  133. T0**s;
  134. m=malloc(sizeof(*m));
  135. *m=M848;
  136. if(argc){
  137. s=malloc(argc*sizeof(*s));
  138. m->_storage=s;
  139. m->_capacity=argc;
  140. m->_lower=1;
  141. m->_upper=argc;
  142. va_start(pa,argc);
  143. while(argc--){
  144. *(s++)=((void*)(va_arg(pa,char*)));
  145. }
  146. va_end(pa);
  147. }
  148. return m;}
  149. void*se_ma147(int argc,...){
  150. T147*m;
  151. va_list pa;
  152. T0**s;
  153. m=malloc(sizeof(*m));
  154. *m=M147;
  155. if(argc){
  156. s=malloc(argc*sizeof(*s));
  157. m->_storage=s;
  158. m->_capacity=argc;
  159. m->_lower=1;
  160. m->_upper=argc;
  161. va_start(pa,argc);
  162. while(argc--){
  163. *(s++)=((void*)(va_arg(pa,char*)));
  164. }
  165. va_end(pa);
  166. }
  167. return m;}
  168. void*se_ma855(int argc,...){
  169. T855*m;
  170. va_list pa;
  171. T0**s;
  172. m=malloc(sizeof(*m));
  173. *m=M855;
  174. if(argc){
  175. s=malloc(argc*sizeof(*s));
  176. m->_storage=s;
  177. m->_capacity=argc;
  178. m->_lower=1;
  179. m->_upper=argc;
  180. va_start(pa,argc);
  181. while(argc--){
  182. *(s++)=((void*)(va_arg(pa,char*)));
  183. }
  184. va_end(pa);
  185. }
  186. return m;}
  187. void*se_ma26(int argc,...){
  188. T26*m;
  189. va_list pa;
  190. T0**s;
  191. m=malloc(sizeof(*m));
  192. *m=M26;
  193. if(argc){
  194. s=malloc(argc*sizeof(*s));
  195. m->_storage=s;
  196. m->_capacity=argc;
  197. m->_lower=1;
  198. m->_upper=argc;
  199. va_start(pa,argc);
  200. while(argc--){
  201. *(s++)=((void*)(va_arg(pa,char*)));
  202. }
  203. va_end(pa);
  204. }
  205. return m;}
  206. void*se_ma733(int argc,...){
  207. T733*m;
  208. va_list pa;
  209. T0**s;
  210. m=malloc(sizeof(*m));
  211. *m=M733;
  212. if(argc){
  213. s=malloc(argc*sizeof(*s));
  214. m->_storage=s;
  215. m->_capacity=argc;
  216. m->_lower=1;
  217. m->_upper=argc;
  218. va_start(pa,argc);
  219. while(argc--){
  220. *(s++)=((void*)(va_arg(pa,char*)));
  221. }
  222. va_end(pa);
  223. }
  224. return m;}
  225. void*se_ma96(int argc,...){
  226. T96*m;
  227. va_list pa;
  228. T0**s;
  229. m=malloc(sizeof(*m));
  230. *m=M96;
  231. if(argc){
  232. s=malloc(argc*sizeof(*s));
  233. m->_storage=s;
  234. m->_capacity=argc;
  235. m->_lower=1;
  236. m->_upper=argc;
  237. va_start(pa,argc);
  238. while(argc--){
  239. *(s++)=((void*)(va_arg(pa,char*)));
  240. }
  241. va_end(pa);
  242. }
  243. return m;}
  244. void*se_ma608(int argc,...){
  245. T608*m;
  246. va_list pa;
  247. T0**s;
  248. m=malloc(sizeof(*m));
  249. *m=M608;
  250. if(argc){
  251. s=malloc(argc*sizeof(*s));
  252. m->_storage=s;
  253. m->_capacity=argc;
  254. m->_lower=1;
  255. m->_upper=argc;
  256. va_start(pa,argc);
  257. while(argc--){
  258. *(s++)=((void*)(va_arg(pa,char*)));
  259. }
  260. va_end(pa);
  261. }
  262. return m;}
  263. void*se_ma419(int argc,...){
  264. T419*m;
  265. va_list pa;
  266. T0**s;
  267. m=malloc(sizeof(*m));
  268. *m=M419;
  269. if(argc){
  270. s=malloc(argc*sizeof(*s));
  271. m->_storage=s;
  272. m->_capacity=argc;
  273. m->_lower=1;
  274. m->_upper=argc;
  275. va_start(pa,argc);
  276. while(argc--){
  277. *(s++)=((void*)(va_arg(pa,char*)));
  278. }
  279. va_end(pa);
  280. }
  281. return m;}
  282. void*se_ma552(int argc,...){
  283. T552*m;
  284. va_list pa;
  285. T0**s;
  286. m=malloc(sizeof(*m));
  287. *m=M552;
  288. if(argc){
  289. s=malloc(argc*sizeof(*s));
  290. m->_storage=s;
  291. m->_capacity=argc;
  292. m->_lower=1;
  293. m->_upper=argc;
  294. va_start(pa,argc);
  295. while(argc--){
  296. *(s++)=((void*)(va_arg(pa,char*)));
  297. }
  298. va_end(pa);
  299. }
  300. return m;}
  301. void*se_ma681(int argc,...){
  302. T681*m;
  303. va_list pa;
  304. T0**s;
  305. m=malloc(sizeof(*m));
  306. *m=M681;
  307. if(argc){
  308. s=malloc(argc*sizeof(*s));
  309. m->_storage=s;
  310. m->_capacity=argc;
  311. m->_lower=1;
  312. m->_upper=argc;
  313. va_start(pa,argc);
  314. while(argc--){
  315. *(s++)=((void*)(va_arg(pa,char*)));
  316. }
  317. va_end(pa);
  318. }
  319. return m;}
  320. void*se_ma235(int argc,...){
  321. T235*m;
  322. va_list pa;
  323. T0**s;
  324. m=malloc(sizeof(*m));
  325. *m=M235;
  326. if(argc){
  327. s=malloc(argc*sizeof(*s));
  328. m->_storage=s;
  329. m->_capacity=argc;
  330. m->_lower=1;
  331. m->_upper=argc;
  332. va_start(pa,argc);
  333. while(argc--){
  334. *(s++)=((void*)(va_arg(pa,char*)));
  335. }
  336. va_end(pa);
  337. }
  338. return m;}
  339. void*se_ma429(int argc,...){
  340. T429*m;
  341. va_list pa;
  342. T2*s;
  343. m=malloc(sizeof(*m));
  344. *m=M429;
  345. if(argc){
  346. s=malloc(argc*sizeof(*s));
  347. m->_storage=s;
  348. m->_capacity=argc;
  349. m->_lower=1;
  350. m->_upper=argc;
  351. va_start(pa,argc);
  352. while(argc--){
  353. *(s++)=va_arg(pa,int);
  354. }
  355. va_end(pa);
  356. }
  357. return m;}
  358. void*se_ma495(int argc,...){
  359. T495*m;
  360. va_list pa;
  361. T0**s;
  362. m=malloc(sizeof(*m));
  363. *m=M495;
  364. if(argc){
  365. s=malloc(argc*sizeof(*s));
  366. m->_storage=s;
  367. m->_capacity=argc;
  368. m->_lower=1;
  369. m->_upper=argc;
  370. va_start(pa,argc);
  371. while(argc--){
  372. *(s++)=((void*)(va_arg(pa,char*)));
  373. }
  374. va_end(pa);
  375. }
  376. return m;}
  377. void*se_ma948(int argc,...){
  378. T948*m;
  379. va_list pa;
  380. T0**s;
  381. m=malloc(sizeof(*m));
  382. *m=M948;
  383. if(argc){
  384. s=malloc(argc*sizeof(*s));
  385. m->_storage=s;
  386. m->_capacity=argc;
  387. m->_lower=1;
  388. m->_upper=argc;
  389. va_start(pa,argc);
  390. while(argc--){
  391. *(s++)=((void*)(va_arg(pa,char*)));
  392. }
  393. va_end(pa);
  394. }
  395. return m;}
  396. void*se_ma52(int argc,...){
  397. T52*m;
  398. va_list pa;
  399. T0**s;
  400. m=malloc(sizeof(*m));
  401. *m=M52;
  402. if(argc){
  403. s=malloc(argc*sizeof(*s));
  404. m->_storage=s;
  405. m->_capacity=argc;
  406. m->_lower=1;
  407. m->_upper=argc;
  408. va_start(pa,argc);
  409. while(argc--){
  410. *(s++)=((void*)(va_arg(pa,char*)));
  411. }
  412. va_end(pa);
  413. }
  414. return m;}
  415. void*se_ma247(int argc,...){
  416. T247*m;
  417. va_list pa;
  418. T0**s;
  419. m=malloc(sizeof(*m));
  420. *m=M247;
  421. if(argc){
  422. s=malloc(argc*sizeof(*s));
  423. m->_storage=s;
  424. m->_capacity=argc;
  425. m->_lower=1;
  426. m->_upper=argc;
  427. va_start(pa,argc);
  428. while(argc--){
  429. *(s++)=((void*)(va_arg(pa,char*)));
  430. }
  431. va_end(pa);
  432. }
  433. return m;}
  434. void*se_ma764(int argc,...){
  435. T764*m;
  436. va_list pa;
  437. T0**s;
  438. m=malloc(sizeof(*m));
  439. *m=M764;
  440. if(argc){
  441. s=malloc(argc*sizeof(*s));
  442. m->_storage=s;
  443. m->_capacity=argc;
  444. m->_lower=1;
  445. m->_upper=argc;
  446. va_start(pa,argc);
  447. while(argc--){
  448. *(s++)=((void*)(va_arg(pa,char*)));
  449. }
  450. va_end(pa);
  451. }
  452. return m;}
  453. void*se_ma381(int argc,...){
  454. T381*m;
  455. va_list pa;
  456. T0**s;
  457. m=malloc(sizeof(*m));
  458. *m=M381;
  459. if(argc){
  460. s=malloc(argc*sizeof(*s));
  461. m->_storage=s;
  462. m->_capacity=argc;
  463. m->_lower=1;
  464. m->_upper=argc;
  465. va_start(pa,argc);
  466. while(argc--){
  467. *(s++)=((void*)(va_arg(pa,char*)));
  468. }
  469. va_end(pa);
  470. }
  471. return m;}
  472. void*se_ma701(int argc,...){
  473. T701*m;
  474. va_list pa;
  475. T0**s;
  476. m=malloc(sizeof(*m));
  477. *m=M701;
  478. if(argc){
  479. s=malloc(argc*sizeof(*s));
  480. m->_storage=s;
  481. m->_capacity=argc;
  482. m->_lower=1;
  483. m->_upper=argc;
  484. va_start(pa,argc);
  485. while(argc--){
  486. *(s++)=((void*)(va_arg(pa,char*)));
  487. }
  488. va_end(pa);
  489. }
  490. return m;}
  491. void*se_ma382(int argc,...){
  492. T382*m;
  493. va_list pa;
  494. T0**s;
  495. m=malloc(sizeof(*m));
  496. *m=M382;
  497. if(argc){
  498. s=malloc(argc*sizeof(*s));
  499. m->_storage=s;
  500. m->_capacity=argc;
  501. m->_lower=1;
  502. m->_upper=argc;
  503. va_start(pa,argc);
  504. while(argc--){
  505. *(s++)=((void*)(va_arg(pa,char*)));
  506. }
  507. va_end(pa);
  508. }
  509. return m;}
  510. void rsp(void){
  511. printf("Eiffel program crash at run time.\n");
  512. printf("No trace when using option \"-boost\"\n");}
  513. void sigrsp(int sig){
  514. printf("Received signal %d (man signal).\n",sig);
  515. rsp();
  516. exit(1);}
  517.  
  518.